home *** CD-ROM | disk | FTP | other *** search
/ Freelog 125 / Freelog_MarsAvril2015_No125.iso / Musique / Quod Libet / quodlibet-3.3.0-installer.exe / bin / multiprocessing / util.pyc (.txt) < prev   
Python Compiled Bytecode  |  2014-12-31  |  9KB  |  305 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.7)
  3.  
  4. import itertools
  5. import weakref
  6. import atexit
  7. import threading
  8. from subprocess import _args_from_interpreter_flags
  9. from multiprocessing.process import current_process, active_children
  10. __all__ = [
  11.     'sub_debug',
  12.     'debug',
  13.     'info',
  14.     'sub_warning',
  15.     'get_logger',
  16.     'log_to_stderr',
  17.     'get_temp_dir',
  18.     'register_after_fork',
  19.     'is_exiting',
  20.     'Finalize',
  21.     'ForkAwareThreadLock',
  22.     'ForkAwareLocal',
  23.     'SUBDEBUG',
  24.     'SUBWARNING']
  25. NOTSET = 0
  26. SUBDEBUG = 5
  27. DEBUG = 10
  28. INFO = 20
  29. SUBWARNING = 25
  30. LOGGER_NAME = 'multiprocessing'
  31. DEFAULT_LOGGING_FORMAT = '[%(levelname)s/%(processName)s] %(message)s'
  32. _logger = None
  33. _log_to_stderr = False
  34.  
  35. def sub_debug(msg, *args):
  36.     if _logger:
  37.         _logger.log(SUBDEBUG, msg, *args)
  38.  
  39.  
  40. def debug(msg, *args):
  41.     if _logger:
  42.         _logger.log(DEBUG, msg, *args)
  43.  
  44.  
  45. def info(msg, *args):
  46.     if _logger:
  47.         _logger.log(INFO, msg, *args)
  48.  
  49.  
  50. def sub_warning(msg, *args):
  51.     if _logger:
  52.         _logger.log(SUBWARNING, msg, *args)
  53.  
  54.  
  55. def get_logger():
  56.     '''
  57.     Returns logger used by multiprocessing
  58.     '''
  59.     global _logger
  60.     import logging as logging
  61.     import atexit as atexit
  62.     logging._acquireLock()
  63.     
  64.     try:
  65.         if not _logger:
  66.             _logger = logging.getLogger(LOGGER_NAME)
  67.             _logger.propagate = 0
  68.             logging.addLevelName(SUBDEBUG, 'SUBDEBUG')
  69.             logging.addLevelName(SUBWARNING, 'SUBWARNING')
  70.             if hasattr(atexit, 'unregister'):
  71.                 atexit.unregister(_exit_function)
  72.                 atexit.register(_exit_function)
  73.             else:
  74.                 atexit._exithandlers.remove((_exit_function, (), { }))
  75.                 atexit._exithandlers.append((_exit_function, (), { }))
  76.     finally:
  77.         logging._releaseLock()
  78.  
  79.     return _logger
  80.  
  81.  
  82. def log_to_stderr(level = None):
  83.     '''
  84.     Turn on logging and add a handler which prints to stderr
  85.     '''
  86.     global _log_to_stderr
  87.     import logging
  88.     logger = get_logger()
  89.     formatter = logging.Formatter(DEFAULT_LOGGING_FORMAT)
  90.     handler = logging.StreamHandler()
  91.     handler.setFormatter(formatter)
  92.     logger.addHandler(handler)
  93.     if level:
  94.         logger.setLevel(level)
  95.     _log_to_stderr = True
  96.     return _logger
  97.  
  98.  
  99. def get_temp_dir():
  100.     if current_process()._tempdir is None:
  101.         import shutil as shutil
  102.         import tempfile as tempfile
  103.         tempdir = tempfile.mkdtemp(prefix = 'pymp-')
  104.         info('created temp directory %s', tempdir)
  105.         Finalize(None, shutil.rmtree, args = [
  106.             tempdir], exitpriority = -100)
  107.         current_process()._tempdir = tempdir
  108.     return current_process()._tempdir
  109.  
  110. _afterfork_registry = weakref.WeakValueDictionary()
  111. _afterfork_counter = itertools.count()
  112.  
  113. def _run_after_forkers():
  114.     items = list(_afterfork_registry.items())
  115.     items.sort()
  116.     for index, ident, func in items:
  117.         obj = None
  118.         
  119.         try:
  120.             func(obj)
  121.         continue
  122.         except Exception:
  123.             e = None
  124.             info('after forker raised exception %s', e)
  125.             continue
  126.         
  127.  
  128.     
  129.  
  130.  
  131. def register_after_fork(obj, func):
  132.     _afterfork_registry[(_afterfork_counter.next(), id(obj), func)] = obj
  133.  
  134. _finalizer_registry = { }
  135. _finalizer_counter = itertools.count()
  136.  
  137. class Finalize(object):
  138.     '''
  139.     Class which supports object finalization using weakrefs
  140.     '''
  141.     
  142.     def __init__(self, obj, callback, args = (), kwargs = None, exitpriority = None):
  143.         if not exitpriority is None and type(exitpriority) is int:
  144.             raise AssertionError
  145.         if None is not None:
  146.             self._weakref = weakref.ref(obj, self)
  147.         elif not exitpriority is not None:
  148.             raise AssertionError
  149.         self._callback = callback
  150.         self._args = args
  151.         if not kwargs:
  152.             pass
  153.         self._kwargs = { }
  154.         self._key = (exitpriority, _finalizer_counter.next())
  155.         _finalizer_registry[self._key] = self
  156.  
  157.     
  158.     def __call__(self, wr = None):
  159.         '''
  160.         Run the callback unless it has already been called or cancelled
  161.         '''
  162.         
  163.         try:
  164.             del _finalizer_registry[self._key]
  165.         except KeyError:
  166.             sub_debug('finalizer no longer registered')
  167.  
  168.         sub_debug('finalizer calling %s with args %s and kwargs %s', self._callback, self._args, self._kwargs)
  169.         res = self._callback(*self._args, **self._kwargs)
  170.         self._weakref = None
  171.         self._callback = None
  172.         self._args = None
  173.         self._kwargs = None
  174.         self._key = None
  175.         return res
  176.  
  177.     
  178.     def cancel(self):
  179.         '''
  180.         Cancel finalization of the object
  181.         '''
  182.         
  183.         try:
  184.             del _finalizer_registry[self._key]
  185.         except KeyError:
  186.             pass
  187.  
  188.         self._weakref = None
  189.         self._callback = None
  190.         self._args = None
  191.         self._kwargs = None
  192.         self._key = None
  193.  
  194.     
  195.     def still_active(self):
  196.         '''
  197.         Return whether this finalizer is still waiting to invoke callback
  198.         '''
  199.         return self._key in _finalizer_registry
  200.  
  201.     
  202.     def __repr__(self):
  203.         
  204.         try:
  205.             obj = self._weakref()
  206.         except (AttributeError, TypeError):
  207.             obj = None
  208.  
  209.         if obj is None:
  210.             return '<Finalize object, dead>'
  211.         x = None % getattr(self._callback, '__name__', self._callback)
  212.         if self._args:
  213.             x += ', args=' + str(self._args)
  214.         if self._kwargs:
  215.             x += ', kwargs=' + str(self._kwargs)
  216.         if self._key[0] is not None:
  217.             x += ', exitprority=' + str(self._key[0])
  218.         return x + '>'
  219.  
  220.  
  221.  
  222. def _run_finalizers(minpriority = None):
  223.     '''
  224.     Run all finalizers whose exit priority is not None and at least minpriority
  225.  
  226.     Finalizers with highest priority are called first; finalizers with
  227.     the same priority will be called in reverse order of creation.
  228.     '''
  229.     if _finalizer_registry is None:
  230.         return None
  231.     items = [ x for x in _finalizer_registry.items() if f(x) ]
  232.     items.sort(reverse = True)
  233.     for key, finalizer in items:
  234.         sub_debug('calling %s', finalizer)
  235.         
  236.         try:
  237.             finalizer()
  238.         continue
  239.         except Exception:
  240.             None if None is None else (None,)
  241.             None if None is None else (None,)
  242.             import traceback as traceback
  243.             traceback.print_exc()
  244.             continue
  245.         
  246.  
  247.     
  248.     if minpriority is None:
  249.         _finalizer_registry.clear()
  250.  
  251.  
  252. def is_exiting():
  253.     '''
  254.     Returns true if the process is shutting down
  255.     '''
  256.     if not _exiting:
  257.         pass
  258.     return _exiting is None
  259.  
  260. _exiting = False
  261.  
  262. def _exit_function(info = info, debug = debug, _run_finalizers = _run_finalizers, active_children = active_children, current_process = current_process):
  263.     info('process shutting down')
  264.     debug('running all "atexit" finalizers with priority >= 0')
  265.     _run_finalizers(0)
  266.     if current_process() is not None:
  267.         for p in active_children():
  268.             if p._daemonic:
  269.                 info('calling terminate() for daemon %s', p.name)
  270.                 p._popen.terminate()
  271.                 continue
  272.         for p in active_children():
  273.             info('calling join() for process %s', p.name)
  274.             p.join()
  275.         
  276.     debug('running the remaining "atexit" finalizers')
  277.     _run_finalizers()
  278.  
  279. atexit.register(_exit_function)
  280.  
  281. class ForkAwareThreadLock(object):
  282.     
  283.     def __init__(self):
  284.         self._reset()
  285.         register_after_fork(self, ForkAwareThreadLock._reset)
  286.  
  287.     
  288.     def _reset(self):
  289.         self._lock = threading.Lock()
  290.         self.acquire = self._lock.acquire
  291.         self.release = self._lock.release
  292.  
  293.  
  294.  
  295. class ForkAwareLocal(threading.local):
  296.     
  297.     def __init__(self):
  298.         register_after_fork(self, (lambda obj: obj.__dict__.clear()))
  299.  
  300.     
  301.     def __reduce__(self):
  302.         return (type(self), ())
  303.  
  304.  
  305.